﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using ATEC.ATDataCoreNET;
using ATECGeometryNet;
using ATEC.GeometryNET;
using ATEC.GeometryNET.Common;
using SSDPNET;
using SSDPNET.Geom;
using System.Threading;

namespace MeshExample
{
    public partial class MeshTestForm : Form
    {
        public MeshTestForm()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 功能：将给定的PolyfaceMeshObject（多面体网格）对象添加到当前激活的场景中，并设置颜色属性。
        /// 关键类及说明：
        ///     PolyfaceMeshObject: 网格对象，包含多面体数据。 
        ///     ATSceneRef: 场景引用，代表当前激活的图形场景。
        ///     ObjectPropertiesSetter: 用于设置和应用对象的属性（如颜色）。
        /// </summary>
        private void AddMeshToScene(PolyfaceMeshObject meshIn, int color)
        {
            // 获取当前激活的图形场景
            ATSceneRef scene = SSDPNET.ScenesFunctions.SceneRefGetActive();  // 调用玄镜平台的API获取当前激活场景

            // 将传入的PolyfaceMeshObject（meshIn）转化为ATObject对象
            ATEC.ATDataCoreNET.ATObjects.ATObject obj =
                ATEC.ATDataCoreNET.ATObjects.GeometryToATObject.ToObject(scene.GetATScene(), meshIn, null);  // 转换为平台对象（ATObject）

            // 创建一个对象属性设置器实例，用于设置属性
            ObjectPropertiesSetter setter = new ObjectPropertiesSetter();  // 初始化属性设置器

            // 设置对象颜色
            setter.SetColor((uint)color);  // 设置颜色，将int类型的颜色转换为uint

            // 应用设置的颜色属性到对象
            setter.Apply(obj);  // 应用颜色设置到对象上

            // 将对象添加到场景中
            obj.AddToScene();  // 把对象添加到当前场景中进行显示
        }


        /// <summary>
        /// 功能：将给定的CurveSet（曲线集）对象添加到当前激活的场景中，并设置颜色属性。
        /// 关键类及说明：
        ///     CurveSet: 由多个曲线组成的集合，可能包含线段、圆弧等几何形状。 
        ///     ATSceneRef: 场景引用，代表当前激活的图形场景。
        ///     ObjectPropertiesSetter: 用于设置和应用对象的属性（如颜色）。
        /// </summary>
        private void AddCrveToScene(CurveSet crvIn, int color)
        {
            // 获取当前激活的图形场景
            ATSceneRef scene = SSDPNET.ScenesFunctions.SceneRefGetActive();  // 调用玄镜平台的API获取当前激活场景

            // 将传入的CurveSet（crvIn）转化为ATObject对象
            ATEC.ATDataCoreNET.ATObjects.ATObject obj =
                ATEC.ATDataCoreNET.ATObjects.GeometryToATObject.ToObject(scene.GetATScene(), crvIn, null);  // 转换为平台对象（ATObject）

            // 创建一个对象属性设置器实例，用于设置属性
            ObjectPropertiesSetter setter = new ObjectPropertiesSetter();  // 初始化属性设置器

            // 设置对象颜色
            setter.SetColor((uint)color);  // 设置颜色，将int类型的颜色转换为uint

            // 应用设置的颜色属性到对象
            setter.Apply(obj);  // 应用颜色设置到对象上

            // 将对象添加到场景中
            obj.AddToScene();  // 把对象添加到当前场景中进行显示
        }


        /// <summary>
        /// 功能：将指定位置的球体（由点和半径定义）添加到当前激活的场景中，并设置颜色属性。
        /// 关键类及说明：
        ///     ATSphereDetail: 表示球体的详细信息，包含球体的原点和半径。
        ///     BaseSolid: 表示一个基础的实体对象，这里用来创建球体。
        ///     PolyfaceMeshObject: 表示一个多面体网格对象，用于存储和显示三维几何体。
        ///     IPolyfaceConstructionExtention: 扩展类，用于从基础实体创建网格对象。
        ///     AddMeshToScene: 用于将网格对象添加到场景并设置颜色。
        /// </summary>
        private void AddPointToScene(XPoint3d origionPt, double rd, int color)
        {
            // 创建球体的详细信息对象，指定原点和半径
            ATSphereDetail detail2 = new ATSphereDetail(origionPt, rd);  // 使用提供的原点和半径创建球体的细节信息

            // 从球体细节信息创建一个基础的实体对象（球体）
            BaseSolid sphere = BaseSolid.CreateATSphere(detail2);  // 根据球体细节创建球体的基础实体对象

            // 将基础实体转换为多面体网格对象，以便渲染
            PolyfaceMeshObject sphereMesh = IPolyfaceConstructionExtention.CreateFromBaseSolid(sphere);  // 将基础实体（球体）转换为网格对象，便于图形显示

            // 将网格对象添加到场景中，并设置指定的颜色
            AddMeshToScene(sphereMesh, color);  // 调用已有的AddMeshToScene函数，将球体网格添加到场景并设置颜色
        }


        /// <summary>
        /// 功能：从随机生成的空间点创建一个网格对象，并将其添加到场景中。
        /// 关键类及说明：
        ///     XPoint3d: 表示三维空间中的一个点，包含x、y、z坐标。
        ///     PolyfaceMeshObject: 表示一个多面体网格对象，通常用于存储并显示三维网格数据。
        ///     IPolyfaceConstructionExtention: 扩展类，用于生成多面体网格。
        ///     AddMeshToScene: 将生成的网格对象添加到图形平台的场景中。
        /// </summary>
        private void button_createFromPoints_Click(object sender, EventArgs e)
        {
            // 准备随机生成的空间点列表
            List<XPoint3d> randPts = new List<XPoint3d>();  // 用于存储随机生成的点

            int maxX = 100 * 10000; // 100m的范围（x轴）  // 设置x轴坐标的最大值
            int maxY = 100 * 10000; // 100m的范围（y轴）  // 设置y轴坐标的最大值
            int maxZ = 1 * 10000; // 1m的范围（z轴）  // 设置z轴坐标的最大值

            // 初始化随机数生成器，基于当前时间和线程ID
            Random rnd = new Random((int)DateTime.Now.Ticks + Environment.TickCount + Thread.CurrentThread.ManagedThreadId);  // 生成随机数生成器

            // 循环生成10000个随机点
            for (int i = 0; i < 10000; i++) // 生成10000个随机点
            {
                double x = rnd.Next(1, maxX);  // 生成x坐标，范围为[1, maxX]
                double y = rnd.Next(1, maxY);  // 生成y坐标，范围为[1, maxY]
                double z = rnd.Next(-maxZ, maxZ);  // 生成z坐标，范围为[-maxZ, maxZ]
                randPts.Add(new XPoint3d(x, y, z));  // 将生成的点添加到列表中
            }

            // 使用生成的点创建网格对象
            PolyfaceMeshObject mesh = IPolyfaceConstructionExtention.CreateXYTriangulation(randPts);  // 根据生成的点创建一个平面三角网格（XY平面投影）

            // 如果网格对象创建成功，则将其添加到场景
            if (mesh != null)  // 判断网格对象是否为null（即是否成功创建）
            {
                AddMeshToScene(mesh, 1);  // 将网格对象添加到场景中，并设置颜色为1（具体颜色值取决于平台的定义）
            }

            // 弹出消息框，通知用户创建成功
            MessageBox.Show("创建成功");  // 弹出一个对话框，告知用户网格创建成功
        }


        /// <summary>
        /// 功能：通过指定若干个三角形面片的点集合，创建一个网格对象，并将其添加到图形平台的场景中。
        /// 关键类及说明：
        ///     XPoint3d: 表示三维空间中的一个点，包含x、y、z坐标。
        ///     PolyfaceMeshObject: 表示一个多面体网格对象，通常用于存储并显示三维网格数据。
        ///     IPolyfaceConstructionExtention: 扩展类，用于通过三角形面片数据生成多面体网格。
        ///     AddMeshToScene: 将生成的网格对象添加到图形平台的场景中。
        /// </summary>
        private void button_ruledPts_Click(object sender, EventArgs e)
        {
            // 定义五个空间点，作为三角形面片的顶点
            XPoint3d pt1 = new XPoint3d(0, 0, 0);  // 三角形面片的第一个点（0,0,0）
            XPoint3d pt2 = new XPoint3d(100, 0, 10);  // 第二个点（100,0,10）
            XPoint3d pt3 = new XPoint3d(100, 100, 20);  // 第三个点（100,100,20）
            XPoint3d pt4 = new XPoint3d(0, 100, 5);  // 第四个点（0,100,5）
            XPoint3d pt5 = new XPoint3d(-100, 200, 5);  // 第五个点（-100,200,5）

            // 为每个三角形面片定义三个点，创建多个三角形
            List<XPoint3d> trai1 = new List<XPoint3d>() { pt1, pt2, pt3 };  // 定义第一个三角形面片，由pt1、pt2、pt3三个点组成
            List<XPoint3d> trai2 = new List<XPoint3d>() { pt1, pt3, pt4 };  // 定义第二个三角形面片，由pt1、pt3、pt4三个点组成
            List<XPoint3d> trai3 = new List<XPoint3d>() { pt1, pt4, pt5 };  // 定义第三个三角形面片，由pt1、pt4、pt5三个点组成

            // 将多个三角形面片放入一个列表中，形成网格
            List<List<XPoint3d>> trais = new List<List<XPoint3d>>() { trai1, trai2, trai3 };  // 将三个三角形面片列表放入一个总的列表中

            // 使用创建的三角形面片数据生成网格对象
            PolyfaceMeshObject mesh = SSDPNET.Geom.IPolyfaceConstructionExtention.CreateFromTriangles(trais);  // 将面片数据转化为多面体网格对象

            // 如果生成的网格对象不为空，则将其添加到场景中
            if (mesh != null)  // 判断网格对象是否有效（不为null）
            {
                AddMeshToScene(mesh, 1);  // 将生成的网格对象添加到图形平台的场景中，颜色为1（具体颜色值可能需要根据实际情况调整）
            }

            // 弹出消息框，通知用户网格创建成功
            MessageBox.Show("创建成功");  // 弹出对话框，告知用户网格创建成功
        }


        /// <summary> 
        /// 功能：通过给定的多个等点数线串，创建一个网格对象，并将其添加到图形平台的场景中。
        /// 描述：本方法通过三条具有相同点数的线段（曲线）集合，使用“规则面片”生成网格。通过将每条曲线与另一条曲线之间的面片进行连接，形成一个网格模型。
        /// 关键类及说明：
        ///     XPoint3d: 表示三维空间中的一个点，包含x、y、z坐标。
        ///     CurveSet: 表示一组曲线集合，可以通过给定的点集创建直线或其他类型的曲线。
        ///     PolyfaceMeshObject: 表示多面体网格对象，用于存储和显示网格数据。
        ///     IPolyfaceConstructionExtention: 提供了创建网格的方法，支持根据曲线生成规则网格。
        ///     AddMeshToScene: 将生成的网格对象添加到场景中。
        /// </summary>
        private void button_crvParal_Click(object sender, EventArgs e)
        {
            // 定义第一条曲线的点集合
            List<XPoint3d> crv1Pts = new List<XPoint3d>();  // 定义一个点集合，用于存储第一条曲线的点
            crv1Pts.Add(new XPoint3d(0, 0, 0));  // 添加点 (0, 0, 0)
            crv1Pts.Add(new XPoint3d(20, 0, 0));  // 添加点 (20, 0, 0)
            crv1Pts.Add(new XPoint3d(30, 0, 0));  // 添加点 (30, 0, 0)
            crv1Pts.Add(new XPoint3d(40, 0, 0));  // 添加点 (40, 0, 0)

            // 根据点集合创建一条开放边界的线性曲线
            CurveSet crv1 = CurveSet.CreateLinear(crv1Pts, CurveSet.BoundaryType.Open, false);  // 创建线性曲线 crv1

            // 定义第二条曲线的点集合
            List<XPoint3d> crv2Pts = new List<XPoint3d>();  // 定义第二条曲线的点集合
            crv2Pts.Add(new XPoint3d(0, 10, 10));  // 添加点 (0, 10, 10)
            crv2Pts.Add(new XPoint3d(20, 10, 10));  // 添加点 (20, 10, 10)
            crv2Pts.Add(new XPoint3d(30, 10, 10));  // 添加点 (30, 10, 10)
            crv2Pts.Add(new XPoint3d(40, 10, 10));  // 添加点 (40, 10, 10)

            // 根据点集合创建第二条开放边界的线性曲线
            CurveSet crv2 = CurveSet.CreateLinear(crv2Pts, CurveSet.BoundaryType.Open, false);  // 创建线性曲线 crv2

            // 定义第三条曲线的点集合
            List<XPoint3d> crv3Pts = new List<XPoint3d>();  // 定义第三条曲线的点集合
            crv3Pts.Add(new XPoint3d(0, 10, 0));  // 添加点 (0, 10, 0)
            crv3Pts.Add(new XPoint3d(20, 10, 0));  // 添加点 (20, 10, 0)
            crv3Pts.Add(new XPoint3d(30, 10, 0));  // 添加点 (30, 10, 0)
            crv3Pts.Add(new XPoint3d(40, 10, 0));  // 添加点 (40, 10, 0)

            // 根据点集合创建第三条开放边界的线性曲线
            CurveSet crv3 = CurveSet.CreateLinear(crv3Pts, CurveSet.BoundaryType.Open, false);  // 创建线性曲线 crv3

            // 将三条曲线放入一个列表中
            List<CurveSet> crvs = new List<CurveSet>() { crv1, crv2, crv3, crv1 };  // 曲线集合，将 crv1, crv2, crv3 放入一个列表，并且重复 crv1 用于创建面片

            // 使用规则生成法将多条曲线之间的面片连接起来，创建网格对象
            PolyfaceMeshObject mesh = SSDPNET.Geom.IPolyfaceConstructionExtention.CreateFromRuledBetweenCorrespondingCurves(crvs);  // 生成规则面片网格

            // 如果生成的网格对象不为空，则将其添加到场景中
            if (mesh != null)  // 判断网格是否成功生成（即mesh对象不为空）
            {
                AddMeshToScene(mesh, 1);  // 将生成的网格对象添加到图形平台的场景中，颜色为1（具体颜色值根据实际需要调整）
            }

            // 弹出消息框，通知用户网格创建成功
            MessageBox.Show("创建成功");  // 弹出消息框，提示用户网格创建成功
        }


        /// <summary>
        /// 功能：通过给定的闭合曲线创建一个网格对象，并将其添加到图形平台的场景中。
        /// 描述：本方法通过提供一个闭合的曲线（环状），使用图形平台的接口生成网格对象，并将其添加到当前活动的场景中。 
        /// 该方法适用于生成二维区域的网格表示，通常用于显示或操作二维平面上的面片。
        /// 关键类及说明：
        /// XPoint3d: 表示三维空间中的一个点，包含x、y、z坐标。用于定义曲线的顶点位置。
        /// CurveSet: 表示一组曲线集合，可以通过给定的点集创建直线或其他类型的曲线。此处用于定义网格的边界曲线。
        /// PolyfaceMeshObject: 表示多面体网格对象，用于存储和显示网格数据。
        /// IPolyfaceConstructionExtention: 提供了创建网格的方法，支持根据曲线生成区域网格。
        /// AddMeshToScene: 将生成的网格对象添加到场景中，进行显示。
        /// </summary>
        private void button_region_Click(object sender, EventArgs e)
        {
            // 定义四个点，构成一个四边形的顶点
            XPoint3d pt1 = new XPoint3d(0, 0, 0); // 第一个点 (0, 0, 0)
            XPoint3d pt2 = new XPoint3d(100, 0, 10); // 第二个点 (100, 0, 10)
            XPoint3d pt3 = new XPoint3d(100, 100, 20); // 第三个点 (100, 100, 20)
            XPoint3d pt4 = new XPoint3d(0, 100, 5); // 第四个点 (0, 100, 5)

            // 将四个点组合成一个点列表，用于定义一个闭合曲线
            List<XPoint3d> pts = new List<XPoint3d>() { pt1, pt2, pt3, pt4 }; // 点列表包含四个顶点

            // 创建一个闭合曲线，曲线由以上四个点组成，并且标记为外边界（Outer）
            CurveSet crv = CurveSet.CreateLinear(pts, CurveSet.BoundaryType.Outer, false); // 创建线性曲线，表示外边界

            // 使用曲线生成一个网格对象（Mesh），通过闭合区域创建网格
            PolyfaceMeshObject mesh = SSDPNET.Geom.IPolyfaceConstructionExtention.CreateFromRegion(crv); // 从闭合区域（Region）创建网格

            // 检查是否成功创建网格
            if (mesh != null) // 如果网格对象不为空
            {
                // 将生成的网格添加到当前场景中
                AddMeshToScene(mesh, 1); // 调用自定义方法，将网格添加到场景并显示，颜色为1
            }

            // 弹出提示框，显示网格创建成功的消息
            MessageBox.Show("创建成功"); // 显示“创建成功”消息框
        }


        /// <summary>
        /// 功能：使用布尔差操作（Cut）从一个网格中切除另一个网格，模拟类似“模具”操作。
        /// 描述：本方法首先生成一个立方体和一个球体网格，然后通过布尔差操作将球体从立方体中“切割”掉，最后将操作后的结果（包括原始网格）添加到场景中进行显示。
        /// 关键类及说明：
        /// XPoint3d: 表示三维空间中的一个点，包含x、y、z坐标，用于定义几何形状的位置。
        /// XVector3d: 表示三维空间中的一个向量，用于定义几何形状的方向和大小。
        /// ATBoxDetail: 表示立方体的详细信息，用于生成立方体。
        /// ATSphereDetail: 表示球体的详细信息，用于生成球体。
        /// BaseSolid: 用于创建三维几何对象（如立方体、球体等）的基本类。
        /// PolyfaceMeshObject: 表示网格对象，用于存储网格的数据和属性。
        /// PolyfaceMeshObjectExtension.BoolCut: 执行布尔差操作，生成两个网格之间的差集。
        /// XTransform3d: 用于对网格进行几何变换（如平移、旋转等）。
        /// </summary>
        private void button_cut_Click(object sender, EventArgs e)
        {
            // 定义立方体的底部和顶部点
            XPoint3d btmPt = new XPoint3d(0, 0, 0); // 立方体底部点 (0, 0, 0)
            XPoint3d topPt = new XPoint3d(0, 0, 100); // 立方体顶部点 (0, 0, 100)

            // 定义立方体的尺寸
            double baseX = 100; // 立方体在X方向的大小 100
            double baseY = 100; // 立方体在Y方向的大小 100

            // 定义X和Y方向的向量
            XVector3d vecX = new XVector3d(1, 0, 0); // X轴方向的单位向量
            XVector3d vecY = new XVector3d(0, 1, 0); // Y轴方向的单位向量

            // 创建一个立方体详细信息对象，用于描述立方体的尺寸和位置
            ATBoxDetail detail = new ATBoxDetail(btmPt, topPt, vecX, vecY, baseX, baseY, baseX, baseY, true); // 创建立方体详细信息
                                                                                                              // 创建立方体网格对象
            BaseSolid box = BaseSolid.CreateATBox(detail); // 使用立方体详细信息创建立方体

            // 使用上面的立方体创建一个网格对象
            PolyfaceMeshObject boxMesh = IPolyfaceConstructionExtention.CreateFromBaseSolid(box); // 从立方体生成网格对象

            // 创建球体的详细信息
            ATSphereDetail detail2 = new ATSphereDetail(topPt, 50); // 创建球体详细信息，球心在topPt，半径为50
                                                                    // 创建球体对象
            BaseSolid sphere = BaseSolid.CreateATSphere(detail2); // 创建球体

            // 使用球体详细信息创建一个网格对象
            PolyfaceMeshObject sphereMesh = IPolyfaceConstructionExtention.CreateFromBaseSolid(sphere); // 从球体生成网格对象

            // 定义布尔操作是否为模具模式，如果为true，表示切割时不填补缺口
            bool bIsCookieCutter = true; // true 表示球体切割后不会填补缺口
                                         // 执行布尔差操作，将球体从立方体中切割掉
            PolyfaceMeshObject meshData = PolyfaceMeshObjectExtension.BoolCut(boxMesh, sphereMesh, bIsCookieCutter); // 执行布尔差操作

            // 如果差集网格不为空，则将生成的网格添加到场景中
            if (meshData != null) // 如果差集网格不为空
            {
                // 将立方体网格添加到场景中并显示，颜色为1
                AddMeshToScene(boxMesh, 1); // 添加立方体网格到场景

                // 将球体网格添加到场景中并显示，颜色为2
                AddMeshToScene(sphereMesh, 2); // 添加球体网格到场景

                // 创建平移变换，将差集网格平移到新的位置 (200, 0, 0)
                XTransform3d trans = XTransform3d.FromTranslation(new XPoint3d(200, 0, 0)); // 创建平移变换
                                                                                            // 执行平移变换，移动差集网格
                meshData.Transform(ref trans, false); // 应用平移变换

                // 将变换后的差集网格添加到场景中并显示，颜色为3
                AddMeshToScene(meshData, 3); // 添加变换后的差集网格到场景
            }

            // 弹出消息框，显示创建成功的提示
            MessageBox.Show("创建成功"); // 弹出“创建成功”提示框
        }


        /// <summary>
        /// 功能：使用布尔求交操作（Intersect）从两个网格中计算交集部分，并将结果展示到场景中。
        /// 描述：本方法首先生成一个立方体和一个球体网格，然后通过布尔求交操作计算它们的交集部分。
        ///      最终将交集结果及原始网格一同添加到场景中，以直观展示求交效果。
        /// 关键类及说明：
        /// XPoint3d: 表示三维空间中的一个点，包含 x、y、z 坐标，用于定义几何形状的位置。
        /// XVector3d: 表示三维空间中的一个向量，用于定义几何形状的方向和大小。
        /// ATBoxDetail: 表示立方体的详细信息，用于定义长方体的形状和尺寸。
        /// ATSphereDetail: 表示球体的详细信息，用于定义球体的中心位置和半径。
        /// BaseSolid: 用于生成三维几何对象（如立方体、球体等）的基本类。
        /// PolyfaceMeshObject: 表示网格对象，用于存储网格的几何和拓扑信息。
        /// PolyfaceMeshObjectExtension.BoolIntersect: 执行布尔求交操作，计算两个网格之间的交集部分。
        /// XTransform3d: 提供几何变换（如平移、旋转、缩放等）的支持，用于调整网格的位置或形状。
        /// </summary>

        private void button_intersect_Click(object sender, EventArgs e)
        {
            // 定义底部和顶部的参考点
            XPoint3d btmPt = new XPoint3d(0, 0, 0); // 底部点
            XPoint3d topPt = new XPoint3d(0, 0, 100); // 顶部点

            // 定义矩形的底边宽度和高度
            double baseX = 100; // 矩形的 X 方向宽度
            double baseY = 100; // 矩形的 Y 方向高度

            // 定义矩形的方向向量
            XVector3d vecX = new XVector3d(1, 0, 0); // X 方向单位向量
            XVector3d vecY = new XVector3d(0, 1, 0); // Y 方向单位向量

            // 创建长方体的详细信息
            ATBoxDetail detail = new ATBoxDetail(
                btmPt, // 底部点
                topPt, // 顶部点
                vecX,  // X 方向向量
                vecY,  // Y 方向向量
                baseX, // X 方向底部宽度
                baseY, // Y 方向底部宽度
                baseX, // X 方向顶部宽度
                baseY, // Y 方向顶部宽度
                true   // 是否闭合顶面
            );

            // 创建长方体几何体
            BaseSolid box = BaseSolid.CreateATBox(detail); // 调用平台函数创建长方体对象
            PolyfaceMeshObject boxMesh = IPolyfaceConstructionExtention.CreateFromBaseSolid(box); // 生成长方体对应的 Mesh

            // 创建球体的详细信息
            ATSphereDetail detail2 = new ATSphereDetail(topPt, 50); // 定义球体的中心点和半径
            BaseSolid sphere = BaseSolid.CreateATSphere(detail2); // 创建球体
            PolyfaceMeshObject sphereMesh = IPolyfaceConstructionExtention.CreateFromBaseSolid(sphere); // 生成球体对应的 Mesh

            // 对长方体和球体进行布尔求交操作
            PolyfaceMeshObject meshData = PolyfaceMeshObjectExtension.BoolIntersect(boxMesh, sphereMesh); // 计算求交结果

            if (meshData != null) // 检查求交结果是否有效
            {
                AddMeshToScene(boxMesh, 1); // 将原始长方体添加到场景中
                AddMeshToScene(sphereMesh, 2); // 将原始球体添加到场景中

                // 对求交结果进行平移操作
                XTransform3d trans = XTransform3d.FromTranslation(new XPoint3d(200, 0, 0)); // 平移变换矩阵
                meshData.Transform(ref trans, false); // 应用平移变换到 Mesh
                AddMeshToScene(meshData, 3); // 将变换后的 Mesh 添加到场景中
            }

            // 显示提示信息，表示操作成功
            MessageBox.Show("创建成功"); // 弹出消息框
        }


        /// <summary>
        /// 功能：使用布尔求并操作（Union）计算两个网格的并集部分，并将结果展示到场景中。
        /// 描述：本方法生成一个立方体和一个球体网格，通过布尔求并操作计算它们的合并结果。
        ///      最后将合并结果以及原始网格一并添加到场景中，以直观展示求并效果。
        /// 关键类及说明：
        /// - **XPoint3d**: 表示三维空间中的一个点，定义几何体的基点或其他几何操作的参考点。
        /// - **XVector3d**: 表示三维空间中的一个向量，用于定义几何体的方向或边界。
        /// - **ATBoxDetail**: 定义立方体或长方体的详细信息，如尺寸、基点和方向。
        /// - **ATSphereDetail**: 定义球体的详细信息，如中心点和半径。
        /// - **BaseSolid**: 用于生成基本三维几何体（如立方体、球体）的类。
        /// - **PolyfaceMeshObject**: 表示多面体网格对象，储存几何数据以支持布尔运算。
        /// - **PolyfaceMeshObjectExtension.BoolUnion**: 执行布尔求并操作，将两个网格合并为一个新的网格对象。
        /// - **XTransform3d**: 用于几何变换（如平移），以调整网格在场景中的位置。
        /// </summary>
        private void button_union_Click(object sender, EventArgs e)
        {
            // 定义立方体的底面点和顶面点，用于设置立方体的位置和高度
            XPoint3d btmPt = new XPoint3d(0, 0, 0); // 底面点，定义立方体的基点
            XPoint3d topPt = new XPoint3d(0, 0, 100); // 顶面点，定义立方体的高度范围

            // 定义立方体的底面尺寸
            double baseX = 100; // X方向的边长
            double baseY = 100; // Y方向的边长

            // 定义立方体的方向向量
            XVector3d vecX = new XVector3d(1, 0, 0); // X轴方向向量
            XVector3d vecY = new XVector3d(0, 1, 0); // Y轴方向向量

            // 创建立方体的详细信息并生成立方体几何体
            ATBoxDetail detail = new ATBoxDetail(btmPt, topPt, vecX, vecY, baseX, baseY, baseX, baseY, true); // 定义立方体的几何属性
            BaseSolid box = BaseSolid.CreateATBox(detail); // 创建立方体对象

            // 将立方体转换为网格对象
            PolyfaceMeshObject boxMesh = IPolyfaceConstructionExtention.CreateFromBaseSolid(box); // 将立方体转换为网格

            // 定义球体的中心点和半径
            ATSphereDetail detail2 = new ATSphereDetail(topPt, 50); // 定义球体的几何属性
            BaseSolid sphere = BaseSolid.CreateATSphere(detail2); // 创建球体对象

            // 将球体转换为网格对象
            PolyfaceMeshObject sphereMesh = IPolyfaceConstructionExtention.CreateFromBaseSolid(sphere); // 将球体转换为网格

            // 进行布尔求并操作，生成合并后的网格对象
            PolyfaceMeshObject meshData = PolyfaceMeshObjectExtension.BoolUnion(boxMesh, sphereMesh); // 执行布尔求并操作

            if (meshData != null) // 检查求并结果是否成功生成
            {
                AddMeshToScene(boxMesh, 1); // 将原始立方体网格添加到场景，颜色编号1
                AddMeshToScene(sphereMesh, 2); // 将原始球体网格添加到场景，颜色编号2

                // 对合并后的网格进行平移变换并添加到场景
                XTransform3d trans = XTransform3d.FromTranslation(new XPoint3d(200, 0, 0)); // 定义平移变换，沿X轴平移200单位
                meshData.Transform(ref trans, false); // 应用平移变换
                AddMeshToScene(meshData, 3); // 将合并后的网格添加到场景，颜色编号3
            }

            // 弹出消息框，提示操作完成
            MessageBox.Show("创建成功"); // 显示成功信息
        }

        /// <summary>
        /// 功能：将线串投影到多面体网格上，并将投影结果展示到场景中。
        /// 描述：本方法通过构建区域网格和一条线串，将线串沿指定方向投影到网格表面，生成投影后的线串。
        ///      最后，将原始网格、原始线串以及投影结果一并添加到场景中，以直观展示投影效果。
        /// 关键类及说明：
        /// - **XPoint3d**: 表示三维空间中的一个点，定义几何体的基点或其他几何操作的参考点。
        /// - **CurveSet**: 表示一组连续的曲线，可用于创建闭合或开放的线串几何。
        /// - **PolyfaceMeshObject**: 表示多面体网格对象，支持几何操作和投影功能。
        /// - **PolyfaceMeshObject.SweepLinestringToMesh**: 将线串沿给定方向投影到多面体网格表面，生成投影点集合。
        /// - **XVector3d**: 表示三维空间中的一个向量，用于定义投影方向。
        /// - **AddMeshToScene**: 将网格对象添加到场景中，便于可视化。
        /// - **AddCrveToScene**: 将曲线对象添加到场景中，便于展示曲线信息。
        /// </summary>
        private void button_Sweep_Click(object sender, EventArgs e)
        {
            // 定义区域网格的顶点点集
            XPoint3d pt1 = new XPoint3d(0, 0, 0); // 第一个顶点，网格起点
            XPoint3d pt2 = new XPoint3d(100, 0, 10); // 第二个顶点
            XPoint3d pt3 = new XPoint3d(200, 20, 20); // 第三个顶点
            XPoint3d pt4 = new XPoint3d(300, 50, 5); // 第四个顶点
            XPoint3d pt5 = new XPoint3d(200, 80, 5); // 第五个顶点
            XPoint3d pt6 = new XPoint3d(100, 60, 5); // 第六个顶点

            // 创建区域网格的闭合线串
            List<XPoint3d> pts = new List<XPoint3d>() { pt1, pt2, pt3, pt4, pt5, pt6 }; // 构建区域网格顶点集合
            CurveSet crv = CurveSet.CreateLinear(pts, CurveSet.BoundaryType.Outer, false); // 创建闭合曲线

            // 从闭合线串生成区域网格
            PolyfaceMeshObject mesh = SSDPNET.Geom.IPolyfaceConstructionExtention.CreateFromRegion(crv); // 基于区域创建网格

            if (mesh == null) // 如果网格创建失败，则退出
                return;

            AddMeshToScene(mesh, 1); // 将生成的区域网格添加到场景，颜色编号1

            // 定义投影的线串
            List<XPoint3d> ptLine = new List<XPoint3d>() { new XPoint3d(-10, -10, 100), new XPoint3d(400, 100, 100) }; // 定义原始线串顶点
            CurveSet crvPj = CurveSet.CreateLinear(ptLine, CurveSet.BoundaryType.Open, false); // 创建线串
            AddCrveToScene(crvPj, 3); // 将原始线串添加到场景，颜色编号3

            // 初始化存储投影结果的点集合
            List<XPoint3d> ptProjected = new List<XPoint3d>(); // 用于存储投影结果点的集合

            // 执行线串投影到网格的操作
            mesh.SweepLinestringToMesh(out ptProjected, ptLine, XVector3d.FromXYZ(0, 0, -1)); // 将线串沿Z轴负方向投影到网格

            // 创建投影后的线串
            CurveSet crvPjed = CurveSet.CreateLinear(ptProjected, CurveSet.BoundaryType.Open, false); // 生成投影后的曲线
            AddCrveToScene(crvPjed, 4); // 将投影结果添加到场景，颜色编号4

            // 弹出消息框，提示操作完成
            MessageBox.Show("创建成功"); // 显示成功信息
        }

        /// <summary>
        /// 功能：绘制多面体网格的等高线
        /// 描述：此方法基于生成的多面体网格，按照指定的分割数，将网格沿不同高度的平面切片，
        ///      并绘制出等高线。等高线被稍微抬高以便于在场景中观察。
        /// 关键类及说明：
        /// - **XPoint3d**: 表示三维空间中的点，用于定义网格的顶点。
        /// - **CurveSet**: 表示一组曲线，等高线会作为曲线的集合进行展示。
        /// - **PolyfaceMeshObject**: 表示多面体网格对象，支持几何操作和切片功能。
        /// - **XPlane3d**: 表示三维空间中的平面，用于定义切片的高度位置。
        /// - **AddMeshToScene**: 将网格对象添加到场景中，以便可视化。
        /// - **AddCrveToScene**: 将曲线集合添加到场景中，用于展示等高线。
        /// - **TransformInPlace**: 对曲线集合进行平移操作，用于提高可视化效果。
        /// </summary>
        private void button_Contour_Click(object sender, EventArgs e)
        {
            // 定义区域网格的顶点点集
            XPoint3d pt1 = new XPoint3d(0, 0, 0); // 定义顶点1，作为网格的起点
            XPoint3d pt2 = new XPoint3d(100, 0, 10); // 定义顶点2
            XPoint3d pt3 = new XPoint3d(200, 20, 20); // 定义顶点3
            XPoint3d pt4 = new XPoint3d(300, 50, 5); // 定义顶点4
            XPoint3d pt5 = new XPoint3d(200, 80, 5); // 定义顶点5
            XPoint3d pt6 = new XPoint3d(100, 60, 5); // 定义顶点6

            // 创建区域网格的闭合线串
            List<XPoint3d> pts = new List<XPoint3d>() { pt1, pt2, pt3, pt4, pt5, pt6 }; // 构建网格顶点集合
            CurveSet crv = CurveSet.CreateLinear(pts, CurveSet.BoundaryType.Outer, false); // 创建闭合曲线

            // 从闭合线串生成区域网格
            PolyfaceMeshObject mesh = SSDPNET.Geom.IPolyfaceConstructionExtention.CreateFromRegion(crv); // 基于区域创建网格
            AddMeshToScene(mesh, 1); // 将生成的区域网格添加到场景，颜色编号1

            // 获取网格的三维空间范围
            XRange3d meshRange = mesh.PointRange(); // 获取网格的点范围

            double zMin = meshRange.Low.Z; // 获取网格的最低点Z值
            double zMax = meshRange.High.Z; // 获取网格的最高点Z值

            // 设置等高线的分割数
            int splitCount = 10; // 等高线切片的数量

            for (int i = 0; i < splitCount; i++) // 遍历每一个切片
            {
                double currZ = (i + 1) * meshRange.ZLength() / (double)(splitCount + 1); // 计算当前切片的Z高度
                XPlane3d planeZ = new XPlane3d(new XPoint3d(0, 0, currZ), XVector3d.UnitZ); // 定义切片平面

                // 对网格进行切片，生成等高线
                CurveSet crvHeight = mesh.PlaneSlice(planeZ, false); // 在指定高度对网格进行切片操作
                crvHeight.TransformInPlace(XTransform3d.FromTranslation(new XPoint3d(0, 0, 1))); // 将等高线稍微抬高，以避免与网格重叠

                AddCrveToScene(crvHeight, 4); // 将生成的等高线添加到场景中，颜色编号4
            }

            // 弹出消息框，提示操作完成
            MessageBox.Show("创建成功"); // 显示成功信息
        }

        /// <summary>
        /// 分类：玄镜BIM图形平台/C#开发/示例代码/Mesh/求交。
        /// 内容：展示如何在玄镜BIM图形平台上实现 mesh 与射线的求交点计算。
        /// 功能：通过创建一个 mesh 和一条射线，计算它们的交点，并将结果可视化。
        /// 关键类及说明：
        ///     XPoint3d: 表示三维点的类，用于定义几何体的顶点和射线起点。
        ///     CurveSet: 表示几何曲线的集合，支持创建多边形或开放曲线。
        ///     PolyfaceMeshObject: 表示多面体网格的几何对象，用于构造和处理 mesh 数据。
        ///     ATMeshFuncs: 提供 mesh 操作和计算功能，包括求交操作。
        /// 关键方法：
        ///     MeshIntersectRayWithMeshTrianglesFromPolyfaceArrays: 计算射线与 mesh 的交点。
        /// </summary>
        private void button_ray_Click(object sender, EventArgs e)
        {
            // 定义 mesh 的顶点。 
            XPoint3d pt1 = new XPoint3d(0, 0, 0);   // 顶点1
            XPoint3d pt2 = new XPoint3d(100, 0, 10); // 顶点2
            XPoint3d pt3 = new XPoint3d(200, 20, 20); // 顶点3
            XPoint3d pt4 = new XPoint3d(300, 50, 5);  // 顶点4
            XPoint3d pt5 = new XPoint3d(200, 80, 5);  // 顶点5
            XPoint3d pt6 = new XPoint3d(100, 60, 5);  // 顶点6

            // 将顶点集合用于创建一个闭合的多边形曲线集。
            List<XPoint3d> pts = new List<XPoint3d>() { pt1, pt2, pt3, pt4, pt5, pt6 }; // 顶点列表
            CurveSet crv = CurveSet.CreateLinear(pts, CurveSet.BoundaryType.Outer, false); // 创建外边界的多边形曲线集。

            // 使用多边形曲线集构造一个 mesh 对象。
            PolyfaceMeshObject mesh = SSDPNET.Geom.IPolyfaceConstructionExtention.CreateFromRegion(crv); // 创建 mesh。
            AddMeshToScene(mesh, 1); // 将 mesh 添加到场景中，ID 为 1。

            // 定义射线的起点和方向。
            XPoint3d rayOrigion = new XPoint3d(50, 20, 20); // 射线起点。
            XVector3d rayVec = new XVector3d(0, 0, -1); // 射线方向向量。

            // 计算射线的终点，便于可视化。
            XPoint3d testEndPt = rayOrigion + rayVec * 50; // 终点为起点沿方向延伸 50 单位。
            CurveSet crvPj = CurveSet.CreateLinear(new List<XPoint3d>() { rayOrigion, testEndPt },
                CurveSet.BoundaryType.Open, false); // 创建表示射线的开放曲线集。
            AddCrveToScene(crvPj, 2); // 将射线曲线添加到场景中，ID 为 2。

            // 提取 mesh 的几何数据（顶点索引数组和点集）。
            List<int> meshIndex = new List<int>(); // mesh 面索引数组。
            List<XPoint3d> meshPoints = new List<XPoint3d>(); // mesh 顶点集合。
            int pNumIndexPerFace = 0; // 每个面的索引数。
            int pNumFace = 0; // 面的总数。

            if (StatusInt.Success != ATMeshFuncs.MeshGetPolyfaceArrays(mesh, out meshIndex,
                out meshPoints, out pNumIndexPerFace, out pNumFace)) // 从 mesh 获取多面体数据。
                return; // 如果失败，则返回。

            // 计算射线与 mesh 的交点。
            List<XPoint3d> intersectPts; // 交点坐标集合。
            List<XPoint3d> pBarycentricArray; // 重心坐标集合（如果有）。
            List<double> paramIntersect; // 射线参数化位置。
            List<int> facetIndeces; // 相交的面索引。

            ATMeshFuncs.MeshIntersectRayWithMeshTrianglesFromPolyfaceArrays(out intersectPts,
                out pBarycentricArray, out paramIntersect, out facetIndeces,
                rayOrigion, rayVec, meshPoints, meshIndex, pNumIndexPerFace); // 计算交点。

            if (intersectPts.Count == 0) // 如果没有交点。
                return; // 返回。

            // 将第一个交点可视化。
            AddPointToScene(intersectPts[0], 2, 3); // 添加交点到场景，指定颜色和大小。

            MessageBox.Show("创建成功"); // 提示创建成功。
        }

        /// <summary>
        /// 功能：对多面体网格进行加密处理
        /// 描述：此方法对网格的每个面进行遍历，将其边界线串按照指定的加密系数插值生成密集点集，
        ///      然后通过密集点生成新的三角面片网格，最后组合成新的加密后的网格。
        /// 关键类及说明：
        /// - **XPoint3d**: 表示三维空间中的点，用于定义网格顶点和插值操作。
        /// - **PolyfaceMeshObject**: 表示多面体网格，支持几何操作、遍历和三角化等功能。
        /// - **PolyfaceTraversal**: 用于遍历多面体网格中的面片，访问每个面的顶点数据。
        /// - **IPolyfaceConstructionExtention**: 提供网格构造和三角化工具。
        /// - **CurveSet**: 表示曲线集合，用于从密集点生成新的闭合曲线。
        /// 注意：
        /// - 代码中的加密系数（`denseFactor`）控制了点的密集程度，值越大点越密。
        /// - 对重复点和边的处理需要优化，避免冗余数据。
        /// </summary>
        private void button_denseMesh_Click(object sender, EventArgs e)
        {
            // 定义网格区域的顶点点集
            XPoint3d pt1 = new XPoint3d(0, 0, 0); // 定义顶点1
            XPoint3d pt2 = new XPoint3d(100, 0, 10); // 定义顶点2
            XPoint3d pt3 = new XPoint3d(200, 20, 20); // 定义顶点3
            XPoint3d pt4 = new XPoint3d(300, 50, 5); // 定义顶点4
            XPoint3d pt5 = new XPoint3d(200, 80, 5); // 定义顶点5
            XPoint3d pt6 = new XPoint3d(100, 60, 5); // 定义顶点6

            // 创建网格的闭合线串
            List<XPoint3d> pts = new List<XPoint3d>() { pt1, pt2, pt3, pt4, pt5, pt6 }; // 构建顶点集合
            CurveSet crv = CurveSet.CreateLinear(pts, CurveSet.BoundaryType.Outer, false); // 创建闭合曲线

            // 从闭合线串生成网格
            PolyfaceMeshObject mesh = SSDPNET.Geom.IPolyfaceConstructionExtention.CreateFromRegion(crv); // 基于区域生成网格
            List<List<XPoint3d>> traigs = new List<List<XPoint3d>>(); // 存储所有三角面片点集

            using (PolyfaceTraversal visitor = new PolyfaceTraversal(mesh, true)) // 创建网格遍历器
            {
                int denseFactor = 3; // 加密系数，控制插值点的数量

                // 遍历网格中的每个面
                while (visitor.AdvanceToNextFace())
                {
                    List<XPoint3d> facetPts = new List<XPoint3d>(); // 存储当前面的顶点

                    foreach (XPoint3d pt in visitor.Point) // 遍历当前面的顶点
                    {
                        facetPts.Add(pt); // 添加顶点到集合
                    }
                    if (facetPts.Count == 0) // 如果没有顶点，跳过
                        return;

                    facetPts.Add(facetPts[0]); // 添加第一个顶点，形成闭合

                    List<XPoint3d> densePts = new List<XPoint3d>(); // 存储加密后的点集

                    // 遍历面的每条边，对边界线串进行加密插值
                    for (int i = 0; i < facetPts.Count - 1; i++)
                    {
                        XPoint3d currPt = facetPts[i]; // 当前点
                        XPoint3d nextPt = facetPts[i + 1]; // 下一点

                        for (int j = 0; j <= denseFactor; j++) // 在当前边上生成插值点
                        {
                            XPoint3d interploterPt = XPoint3d.Interpolate(currPt, j / (double)(denseFactor + 1), nextPt); // 线性插值
                            densePts.Add(interploterPt); // 添加插值点到集合
                        }
                    }

                    // 从加密后的点集生成闭合曲线
                    CurveSet crvFacet = CurveSet.CreateLinear(densePts, CurveSet.BoundaryType.Outer, false); // 创建曲线
                    PolyfaceMeshObject facetMesh = IPolyfaceConstructionExtention.CreateFromRegion(crvFacet); // 生成面的网格
                    facetMesh.Triangulate(); // 将网格三角化

                    // 遍历新的网格，提取三角面片点集
                    using (PolyfaceTraversal visitorFacet = new PolyfaceTraversal(facetMesh, true)) // 创建新的网格遍历器
                    {
                        while (visitorFacet.AdvanceToNextFace())
                        {
                            List<XPoint3d> tri = new List<XPoint3d>(); // 存储三角面片点集

                            foreach (XPoint3d pt in visitorFacet.Point) // 遍历三角面的顶点
                            {
                                tri.Add(pt); // 添加顶点到集合
                            }

                            if (tri.Count != 3) // 如果顶点数不是3，跳过（不符合三角形）
                                continue;

                            traigs.Add(tri); // 添加三角面片到总集合
                        }
                    }
                }
            }

            // 从所有三角面片点集生成新的加密网格
            PolyfaceMeshObject denseMesh = IPolyfaceConstructionExtention.CreateFromTriangles(traigs); // 创建新的网格

            if (denseMesh != null) // 如果生成成功
            {
                AddMeshToScene(mesh, 1); // 将原始网格添加到场景，颜色编号1

                XTransform3d trans = XTransform3d.FromTranslation(new XPoint3d(400, 0, 0)); // 定义平移变换
                denseMesh.Transform(ref trans, false); // 平移加密网格
                AddMeshToScene(denseMesh, 3); // 将加密网格添加到场景，颜色编号3
            }

            MessageBox.Show("创建成功"); // 显示操作完成的消息
        }
    }
}
